package person.bluext.singlegateway.common.utils;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.lang3.StringUtils;
import person.bluext.singlegateway.common.exception.BlankParamException;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;

/**
 * Description : 处理请求参数工具
 *
 * @author : bluext
 */
public class ProjectParamUtils {

    /**
     * 获取字符串数组
     *
     * @param paramObj 参数对象
     * @param key      key值
     * @return String[]
     */
    public static String[] getStringArr(JSONObject paramObj, String key) {
        if (paramObj == null) {
            return null;
        }
        JSONArray objArr = paramObj.getJSONArray(key);
        if (objArr == null) {
            return null;
        }
        return paramObj.getJSONArray(key).toArray(new String[]{});
    }

    /**
     * 获取整型数组
     *
     * @param paramObj 参数对象
     * @param key      key值
     * @return Integer[]
     */
    public static Integer[] getIntegerArr(JSONObject paramObj, String key) {
        if (paramObj == null) {
            return null;
        }
        JSONArray objArr = paramObj.getJSONArray(key);
        if (objArr == null) {
            return null;
        }
        return paramObj.getJSONArray(key).toArray(new Integer[]{});
    }

    /**
     * 请求参数是否为空
     *
     * @param paramObj 请求参数Map
     * @return 是否为空
     */
    public static boolean isBlank(JSONObject paramObj) {
        return paramObj == null || paramObj.isEmpty();
    }

    /**
     * 请求参数中key对应的value是否为空
     *
     * @param paramObj 请求参数Map
     * @param key      key值
     * @return 是否为空
     */
    public static boolean isBlank(JSONObject paramObj, String key) {
        return isBlank(paramObj) || StringUtils.isBlank(key) || !paramObj.containsKey(key);
    }

    /**
     * 从请求参数中获取key指定的value
     *
     * @param paramObj 请求参数对象
     * @param key      key值
     * @return value值
     */
    public static String getString(JSONObject paramObj, String key) {
        if (paramObj == null) {
            return null;
        }
        return paramObj.getString(key);
    }

    /**
     * 从请求参数中获取key指定的value
     *
     * @param paramObj 请求参数对象
     * @param key      key值
     * @return value值
     */
    public static Long getLong(JSONObject paramObj, String key) {
        if (paramObj == null) {
            return null;
        }
        return paramObj.getLong(key);
    }

    /**
     * 从请求参数中获取key指定的value
     *
     * @param paramObj 请求参数对象
     * @param key      key值
     * @return value值
     */
    public static Object getObject(JSONObject paramObj, String key) {
        if (paramObj == null) {
            return null;
        }
        return paramObj.get(key);
    }

    /**
     * 从请求参数中获取key指定的指定类型的对象
     *
     * @param paramObj 请求参数对象
     * @param key      key值
     * @param clazz    指定的对象class
     * @param <T>      指定的对象类型
     * @return T
     */
    public static <T> T getObject(JSONObject paramObj, String key, Class<T> clazz) {
        if (paramObj == null) {
            return null;
        }
        return paramObj.getObject(key, clazz);
    }

    /**
     * 从请求参数中获取key指定的value
     *
     * @param paramObj 请求参数对象
     * @param key      key值
     * @return value值
     */
    public static Integer getInteger(JSONObject paramObj, String key) {
        if (paramObj == null) {
            return null;
        }
        return paramObj.getInteger(key);
    }

    /**
     * 从请求参数中获取key指定的value
     *
     * @param paramObj 请求参数对象
     * @param key      key值
     * @return value值
     */
    public static JSONArray getJSONArray(JSONObject paramObj, String key) {
        if (paramObj == null) {
            return null;
        }
        return paramObj.getJSONArray(key);
    }

    /**
     * 从请求参数中获取key指定的value（去除前后空格）
     *
     * @param paramObj 请求对象
     * @param key      key值
     * @return value值
     */
    public static String getTrimValue(JSONObject paramObj, String key) {
        String value = getString(paramObj, key);
        return StringUtils.isBlank(value) ? value : value.trim();
    }

    /**
     * 收集请求参数名
     *
     * @param ParamNames 请求参数名列表
     * @return 收集后的请求参数名列表
     */
    public static String[] collectParamNames(String... ParamNames) {
        return ParamNames;
    }

    /**
     * 收集请求参数值
     *
     * @param paramValues 请求参数值列表
     * @return 收集后的请求参数值
     */
    public static String[] collectParamValues(String... paramValues) {
        return paramValues;
    }

    /**
     * 是否缺失请求参数，抛出对应的错误
     *
     * @param paramNames  请求参数名列表
     * @param paramValues 请求参数值列表
     */
    public static void isAnyParamBlank(String[] paramNames, String[] paramValues) {
        for (int i = 0; i < paramValues.length; i++) {
            if (StringUtils.isBlank(paramValues[i])) {
                throw new BlankParamException(paramNames[i]);
            }
        }
    }

    /**
     * <pre>
     *  解析Query String -> Map 如：a=1&b=2&c=3   ====> {"a":"1","b":"2","c":"3"}
     * </pre>
     *
     * @param queryString 字符串如： a=1&b=2&c=3
     * @return map
     */
    public static Map<String, String> parseQueryString(String queryString) throws UnsupportedEncodingException {
        Map<String, String> paramMap = new HashMap<>();
        if (StringUtils.isBlank(queryString)) {
            return paramMap;
        }
        String tempURL = URLDecoder.decode(queryString, "UTF-8");
        StringTokenizer st = null;
        if (tempURL != null) {
            st = new StringTokenizer(tempURL, "&");
        }
        if (st != null) {
            while (st.hasMoreTokens()) {
                String pairs = st.nextToken();
                String key = pairs.substring(0, pairs.indexOf('='));
                String value = pairs.substring(pairs.indexOf('=') + 1);
                paramMap.put(key, value);
            }
        }
        return paramMap;
    }

}
